package Poker;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.GridLayout;
import java.awt.Image;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JSlider;
import javax.swing.JTextField;
import javax.swing.Timer;

/**
 *
 * @author Ziad Aloulou
 */
public class Affichage extends JPanel implements ActionListener {

    private Main.Frame frame;
    private Evenements evenements;
    private Evenements evenement;
    public int addition1 = 0;
    public int addition2 = 0;
    //
    public JPanel pnlPoker = new JPanel(new GridLayout(2, 3));
    public JButton btnCheck = new JButton("Check");
    public JButton btnRaise = new JButton("Raise");
    public JButton btnBet = new JButton("Bet");
    public JButton btnFold = new JButton("Fold");
    public JTextField txtRaise = new JTextField();
    public JSlider sldBet = new JSlider();
    //
    public int nbJoueurs = 7;
    public int bet = 0;
    public int blind = 10;
    int x = 0;
    int z = 0;
    public JoueurPoker[] joueurs;
    public int[][] tableauPositionHand0 = new int[7][2];
    public int[][] tableauPositionHand1 = new int[7][2];
    public JLabel labelChips0;
    public JLabel labelChips1;
    public JLabel labelChips2;
    public JLabel labelChips3;
    public JLabel labelChips4;
    public JLabel labelChips5;
    public JLabel labelChips6;
    public JLabel labelChips7;
    public Timer timer;
    public int vitesse = 0;
    public Draw nouveau;
    Image IMAGE_TABLE = Toolkit.getDefaultToolkit().createImage("Images/Table.JPG");
    Image IMAGE_PILE = Toolkit.getDefaultToolkit().createImage("Images/Pile.JPG");
    Image JETON = Toolkit.getDefaultToolkit().createImage("jeton8.JPG");
    //
    public boolean quadrant1 = false;
    public boolean quadrant2 = false;
    public boolean quadrant3 = false;
    public boolean quadrant4 = false;

    /**
     * Constructeur de la classe Affichage
     */
    public Affichage(Main.Frame frame) {
        this.frame = frame;
        frame.setSize(950, 625);

        sldBet.setMajorTickSpacing(frame.argent / 10);
        sldBet.setMinorTickSpacing(frame.argent / 20);
        sldBet.setPaintTicks(true);
        sldBet.setMaximum(frame.argent);
        sldBet.setMinimum(blind);
        timer = new Timer(vitesse, this);
        //sldBet.setPaintLabels(true);
//        content.add(sldBet, BorderLayout.SOUTH);

        btnRaise.setEnabled(false);
        pnlPoker.add(btnCheck);
        pnlPoker.add(btnRaise);
        pnlPoker.add(btnFold);
        pnlPoker.add(btnBet);
        pnlPoker.add(sldBet);
        pnlPoker.add(txtRaise);

        joueurs = new JoueurPoker[nbJoueurs];
        for (int i = 0; i < nbJoueurs; i++) {
            joueurs[i] = new JoueurPoker(1000, i);
            joueurs[i].setHand0(new Card());
            joueurs[i].setHand1(new Card());
        }
        initPositionCartes();
        
        nouveau = new Draw(joueurs, nbJoueurs);
        evenements = new Evenements(frame, this, joueurs, nbJoueurs);
        evenement = new Evenements(frame, this, joueurs);
        sldBet.addChangeListener(evenement);
        btnCheck.addActionListener(evenements);
        btnFold.addActionListener(evenements);
        btnRaise.addActionListener(evenements);
        btnBet.addActionListener(evenements);
        txtRaise.addKeyListener(evenement);
        checkQuadrant(0);
        timer.start();

        labelChips0 = new JLabel("" +joueurs[0].getChips());
        labelChips1 = new JLabel("" +joueurs[1].getChips());
        labelChips2 = new JLabel("" +joueurs[2].getChips());
        labelChips3 = new JLabel("" +joueurs[3].getChips());
        labelChips4 = new JLabel("" +joueurs[4].getChips());
        labelChips5 = new JLabel("" +joueurs[5].getChips());
        labelChips6 = new JLabel("" +joueurs[6].getChips());

        labelChips0.setLocation(0, 0);
        labelChips0.setBounds(0, 0, 10, 100);
        labelChips0.setBackground(Color.red);
//        pnlPoker.add(labelChips1);
//        pnlPoker.add(labelChips2);
//        pnlPoker.add(labelChips3);
//        pnlPoker.add(labelChips4);
//        pnlPoker.add(labelChips5);
//        pnlPoker.add(labelChips6);
//        pnlPoker.add(labelChips7);

        this.add(pnlPoker, BorderLayout.SOUTH);
    }

    /**
     * Initialisation des positions des cartes
     */
    public void initPositionCartes() {
        for (int i = 0; i < 7; i++) {
            joueurs[i].getHand0().setPositionX(400);
            joueurs[i].getHand1().setPositionX(400);
            joueurs[i].getHand0().setPositionY(250);
            joueurs[i].getHand1().setPositionY(250);
        }

        //initialisation des tableaux qui gardent en mémoire les positions finales des cartes qui constituent la première carte de la main d'un joueur
        tableauPositionHand0[0][0] = 805;
        tableauPositionHand0[0][1] = 90;
        tableauPositionHand0[1][0] = 805;
        tableauPositionHand0[1][1] = 360;
        tableauPositionHand0[2][0] = 605;
        tableauPositionHand0[2][1] = 475;
        tableauPositionHand0[3][0] = 405;
        tableauPositionHand0[3][1] = 475;
        tableauPositionHand0[4][0] = 205;
        tableauPositionHand0[4][1] = 475;
        tableauPositionHand0[5][0] = 5;
        tableauPositionHand0[5][1] = 360;
        tableauPositionHand0[6][0] = 5;
        tableauPositionHand0[6][1] = 90;

        //initialisation des tableaux qui gardent en mémoire les positions finales des cartes qui constituent la deuxième carte de la main d'un joueur
        tableauPositionHand1[0][0] = 865;
        tableauPositionHand1[0][1] = 90;
        tableauPositionHand1[1][0] = 865;
        tableauPositionHand1[1][1] = 360;
        tableauPositionHand1[2][0] = 665;
        tableauPositionHand1[2][1] = 475;
        tableauPositionHand1[3][0] = 465;
        tableauPositionHand1[3][1] = 475;
        tableauPositionHand1[4][0] = 265;
        tableauPositionHand1[4][1] = 475;
        tableauPositionHand1[5][0] = 65;
        tableauPositionHand1[5][1] = 360;
        tableauPositionHand1[6][0] = 65;
        tableauPositionHand1[6][1] = 90;

    }

    /**
     * Détermine dans quel quadrant se situe la position finale d'une carte
     */
    public void checkQuadrant(int i) {
        System.out.println(x);
        System.out.println(tableauPositionHand0[i][0] - 400);
        System.out.println(tableauPositionHand0[i][1] - 250);
        if (tableauPositionHand0[i][0] - 400 > 0 && tableauPositionHand0[i][1] - 250 < 0) {
            quadrant1 = true;
            quadrant2 = false;
            quadrant3 = false;
            quadrant4 = false;
        }
        if (tableauPositionHand0[i][0] - 400 < 0 && tableauPositionHand0[i][1] - 250 < 0) {
            quadrant1 = false;
            quadrant2 = true;
            quadrant3 = false;
            quadrant4 = false;
        }
        if (tableauPositionHand0[i][0] - 400 < 0 && tableauPositionHand0[i][1] - 250 > 0) {
            quadrant1 = false;
            quadrant2 = false;
            quadrant3 = true;
            quadrant4 = false;
        }
        if (tableauPositionHand0[i][0] - 400 > 0 && tableauPositionHand0[i][1] - 250 > 0) {
            quadrant1 = false;
            quadrant2 = false;
            quadrant3 = false;
            quadrant4 = true;
        }
    }

    /**
     * Modification des positions des cartes
     * @param i
     */
    public void modPositionCartesHand0(int i) {
        //initialisation des positions des cartes
        double int1 = Math.abs(tableauPositionHand0[i][0] - joueurs[i].getHand0().getPositionX());
        double int2 = Math.abs(tableauPositionHand0[i][1] - joueurs[i].getHand0().getPositionY());
        double int3 = int1 / int2;
        int int4 = (int) Math.round(int3);
        if (int4 >= 1) {
            addition1 += int4;
            addition2 += 1;
            if (quadrant1 == true) {
                joueurs[z].getHand0().setPositionX(joueurs[z].getHand0().getPositionX() + addition1);
                joueurs[z].getHand0().setPositionY(joueurs[z].getHand0().getPositionY() - addition2);
            } else if (quadrant2 == true) {
                joueurs[z].getHand0().setPositionX(joueurs[z].getHand0().getPositionX() - addition1);
                joueurs[z].getHand0().setPositionY(joueurs[z].getHand0().getPositionY() - addition2);
            } else if (quadrant3 == true) {
                joueurs[z].getHand0().setPositionX(joueurs[z].getHand0().getPositionX() - addition1);
                joueurs[z].getHand0().setPositionY(joueurs[z].getHand0().getPositionY() + addition2);
            } else if (quadrant4 == true) {
                joueurs[z].getHand0().setPositionX(joueurs[z].getHand0().getPositionX() + addition1);
                joueurs[z].getHand0().setPositionY(joueurs[z].getHand0().getPositionY() + addition2);
            }
        } else {
            addition1 += 1;
            int int5 = (int) Math.round(1 / int3);
            addition2 += int5;
            if (quadrant1 == true) {
                joueurs[z].getHand0().setPositionX(joueurs[z].getHand0().getPositionX() + addition1);
                joueurs[z].getHand0().setPositionY(joueurs[z].getHand0().getPositionY() - addition2);
            } else if (quadrant2 == true) {
                joueurs[z].getHand0().setPositionX(joueurs[z].getHand0().getPositionX() - addition1);
                joueurs[z].getHand0().setPositionY(joueurs[z].getHand0().getPositionY() - addition2);
            } else if (quadrant3 == true) {
                joueurs[z].getHand0().setPositionX(joueurs[z].getHand0().getPositionX() - addition1);
                joueurs[z].getHand0().setPositionY(joueurs[z].getHand0().getPositionY() + addition2);
            } else if (quadrant4 == true) {
                joueurs[z].getHand0().setPositionX(joueurs[z].getHand0().getPositionX() + addition1);
                joueurs[z].getHand0().setPositionY(joueurs[z].getHand0().getPositionY() + addition2);
            }
        }

    }

    /**
     * Modification des positions des cartes
     * @param i
     */
    public void modPositionCartesHand1(int i) {
        //initialisation des positions des cartes
        double int1 = Math.abs(tableauPositionHand1[i][0] - joueurs[i].getHand1().getPositionX());
        double int2 = Math.abs(tableauPositionHand1[i][1] - joueurs[i].getHand1().getPositionY());
        double int3 = int1 / int2;
        int int4 = (int) Math.round(int3);
        if (int4 >= 1) {
            addition1 += int4;
            addition2 += 1;
            if (quadrant1 == true) {
                joueurs[x].getHand1().setPositionX(joueurs[x].getHand1().getPositionX() + addition1);
                joueurs[x].getHand1().setPositionY(joueurs[x].getHand1().getPositionY() - addition2);
            } else if (quadrant2 == true) {
                joueurs[x].getHand1().setPositionX(joueurs[x].getHand1().getPositionX() - addition1);
                joueurs[x].getHand1().setPositionY(joueurs[x].getHand1().getPositionY() - addition2);
            } else if (quadrant3 == true) {
                joueurs[x].getHand1().setPositionX(joueurs[x].getHand1().getPositionX() - addition1);
                joueurs[x].getHand1().setPositionY(joueurs[x].getHand1().getPositionY() + addition2);
            } else if (quadrant4 == true) {
                joueurs[x].getHand1().setPositionX(joueurs[x].getHand1().getPositionX() + addition1);
                joueurs[x].getHand1().setPositionY(joueurs[x].getHand1().getPositionY() + addition2);
            }
        } else {
            addition1 += 1;
            int int5 = (int) Math.round(1 / int3);
            addition2 += int5;
            if (quadrant1 == true) {
                joueurs[x].getHand1().setPositionX(joueurs[x].getHand1().getPositionX() + addition1);
                joueurs[x].getHand1().setPositionY(joueurs[x].getHand1().getPositionY() - addition2);
            } else if (quadrant2 == true) {
                joueurs[x].getHand1().setPositionX(joueurs[x].getHand1().getPositionX() - addition1);
                joueurs[x].getHand1().setPositionY(joueurs[x].getHand1().getPositionY() - addition2);
            } else if (quadrant3 == true) {
                joueurs[x].getHand1().setPositionX(joueurs[x].getHand1().getPositionX() - addition1);
                joueurs[x].getHand1().setPositionY(joueurs[x].getHand1().getPositionY() + addition2);
            } else if (quadrant4 == true) {
                joueurs[x].getHand1().setPositionX(joueurs[x].getHand1().getPositionX() + addition1);
                joueurs[x].getHand1().setPositionY(joueurs[x].getHand1().getPositionY() + addition2);
            }
        }

    }

    public void validation() {


        double[][] tableau1 = new double[7][nbJoueurs];
        double[][] tableauStraight = new double[7][nbJoueurs];
        double a = 0;

        for (int i = 0; i < nbJoueurs; i++) {
            tableau1[i][0] = joueurs[i].getHand0().getNombre();
            tableau1[i][1] = joueurs[i].getHand1().getNombre();
            tableau1[i][2] = nouveau.getFlop1().getNombre();
            tableau1[i][3] = nouveau.getFlop2().getNombre();
            tableau1[i][4] = nouveau.getFlop3().getNombre();
            tableau1[i][5] = nouveau.getTurn().getNombre();
            tableau1[i][6] = nouveau.getRiver().getNombre();
        }

        for (int i = 0; i < nbJoueurs; i++) {
            for (int j = 0; j < 7; j++) {
                if (tableau1[i][j] == 0) {
                    tableau1[i][j] = 13;
                }
                if (tableau1[i][j] == 1) {
                    tableau1[i][j] = 14;
                }
            }
        }

        for (int i = 0; i < nbJoueurs; i++) {
            for (int k = 0; k < 8; k++) {
                for (int j = 0; j < 6; j++) {
                    if (tableau1[i][j] > tableau1[i][j + 1]) {
                        a = tableau1[i][j];
                        tableau1[i][j] = tableau1[i][j + 1];
                        tableau1[i][j + 1] = a;
                    }
                }
            }
        }

        for (int i = 0; i < nbJoueurs; i++) {
            for (int j = 0; j < 7; j++) {
                tableauStraight[i][j] = tableau1[i][j];
            }
        }

        for (int i = 0; i < nbJoueurs; i++) {
            for (int j = 0; j < 6; j++) {
                for (int k = 0; k < 2; k++) {
                    if (tableauStraight[i][j] == tableauStraight[i][j + 1]) {
                        tableauStraight[i][j] = 100;
                    }
                }
            }
        }

        for (int i = 0; i < nbJoueurs; i++) {
            for (int k = 0; k < 8; k++) {
                for (int j = 0; j < 6; j++) {
                    if (tableauStraight[i][j] > tableauStraight[i][j + 1]) {
                        a = tableauStraight[i][j];
                        tableauStraight[i][j] = tableauStraight[i][j + 1];
                        tableauStraight[i][j + 1] = a;
                    }
                }
            }
        }

        for (int i = 0; i < nbJoueurs; i++) {
            for (int j = 0; j < 7; j++) {
                System.out.println(tableauStraight[i][j]);
            }
            System.out.println("");
            System.out.println("");
        }

        for (int i = 0; i < nbJoueurs; i++) {
            if ((joueurs[i].getHand0().getNombre() == joueurs[i].getHand1().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getFlop1().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getFlop2().getNombre())
                    || (joueurs[i].getHand0().getNombre() == joueurs[i].getHand1().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getFlop1().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getFlop3().getNombre())
                    || (joueurs[i].getHand0().getNombre() == joueurs[i].getHand1().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getFlop1().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand0().getNombre() == joueurs[i].getHand1().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getFlop1().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == joueurs[i].getHand1().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getFlop2().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getFlop3().getNombre())
                    || (joueurs[i].getHand0().getNombre() == joueurs[i].getHand1().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getFlop2().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand0().getNombre() == joueurs[i].getHand1().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getFlop2().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == joueurs[i].getHand1().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getFlop3().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand0().getNombre() == joueurs[i].getHand1().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getFlop3().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == joueurs[i].getHand1().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getTurn().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop1().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getFlop2().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getFlop3().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop1().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getFlop2().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop1().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getFlop2().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop2().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getFlop3().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop2().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getFlop3().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop3().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getTurn().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop1().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getFlop2().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getFlop3().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop1().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getFlop2().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop1().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getFlop2().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop2().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getFlop3().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop2().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getFlop3().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop3().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getTurn().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getRiver().getNombre())
                    || (nouveau.getFlop1().getNombre() == nouveau.getFlop2().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getFlop3().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getTurn().getNombre())
                    || (nouveau.getFlop1().getNombre() == nouveau.getFlop2().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getFlop3().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getRiver().getNombre())
                    || (nouveau.getFlop1().getNombre() == nouveau.getFlop3().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getTurn().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getRiver().getNombre())
                    || (nouveau.getFlop2().getNombre() == nouveau.getFlop3().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getTurn().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getRiver().getNombre())) {
                System.out.println("Joueur " + (i + 1) + ": Quads!!!!");
                joueurs[i].setPower(2);

            } else if ((joueurs[i].getHand0().getNombre() == joueurs[i].getHand1().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getFlop1().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getFlop3().getNombre())
                    || (joueurs[i].getHand0().getNombre() == joueurs[i].getHand1().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getFlop1().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand0().getNombre() == joueurs[i].getHand1().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getFlop1().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == joueurs[i].getHand1().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getFlop1().getNombre()
                    && nouveau.getFlop3().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand0().getNombre() == joueurs[i].getHand1().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getFlop1().getNombre()
                    && nouveau.getFlop3().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == joueurs[i].getHand1().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getFlop1().getNombre()
                    && nouveau.getTurn().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == joueurs[i].getHand1().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getFlop2().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getFlop3().getNombre())
                    || (joueurs[i].getHand0().getNombre() == joueurs[i].getHand1().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getFlop2().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand0().getNombre() == joueurs[i].getHand1().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getFlop2().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == joueurs[i].getHand1().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getFlop2().getNombre()
                    && nouveau.getFlop3().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand0().getNombre() == joueurs[i].getHand1().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getFlop2().getNombre()
                    && nouveau.getFlop3().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == joueurs[i].getHand1().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getFlop2().getNombre()
                    && nouveau.getTurn().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == joueurs[i].getHand1().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getFlop3().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getFlop2().getNombre())
                    || (joueurs[i].getHand0().getNombre() == joueurs[i].getHand1().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getFlop3().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand0().getNombre() == joueurs[i].getHand1().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getFlop3().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == joueurs[i].getHand1().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getFlop3().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand0().getNombre() == joueurs[i].getHand1().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getFlop3().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == joueurs[i].getHand1().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getFlop3().getNombre()
                    && nouveau.getTurn().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == joueurs[i].getHand1().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getTurn().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getFlop2().getNombre())
                    || (joueurs[i].getHand0().getNombre() == joueurs[i].getHand1().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getTurn().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getFlop3().getNombre())
                    || (joueurs[i].getHand0().getNombre() == joueurs[i].getHand1().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getTurn().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == joueurs[i].getHand1().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getTurn().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getFlop3().getNombre())
                    || (joueurs[i].getHand0().getNombre() == joueurs[i].getHand1().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getTurn().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == joueurs[i].getHand1().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getTurn().getNombre()
                    && nouveau.getFlop3().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == joueurs[i].getHand1().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getRiver().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getFlop2().getNombre())
                    || (joueurs[i].getHand0().getNombre() == joueurs[i].getHand1().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getRiver().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getFlop3().getNombre())
                    || (joueurs[i].getHand0().getNombre() == joueurs[i].getHand1().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getRiver().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand0().getNombre() == joueurs[i].getHand1().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getRiver().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getFlop3().getNombre())
                    || (joueurs[i].getHand0().getNombre() == joueurs[i].getHand1().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getRiver().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand0().getNombre() == joueurs[i].getHand1().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getRiver().getNombre()
                    && nouveau.getFlop3().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand0().getNombre() == joueurs[i].getHand1().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getFlop2().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getFlop3().getNombre())
                    || (joueurs[i].getHand0().getNombre() == joueurs[i].getHand1().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getFlop2().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand0().getNombre() == joueurs[i].getHand1().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getFlop2().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == joueurs[i].getHand1().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getFlop3().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand0().getNombre() == joueurs[i].getHand1().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getFlop3().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == joueurs[i].getHand1().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getTurn().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == joueurs[i].getHand1().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getFlop3().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand0().getNombre() == joueurs[i].getHand1().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getFlop3().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == joueurs[i].getHand1().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getTurn().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == joueurs[i].getHand1().getNombre()
                    && nouveau.getFlop3().getNombre() == nouveau.getTurn().getNombre()
                    && nouveau.getFlop3().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop1().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getFlop2().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getFlop3().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop1().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getFlop2().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop1().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getFlop2().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop1().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getFlop3().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop1().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getFlop3().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop1().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getTurn().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop2().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getFlop1().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getFlop3().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop2().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getFlop1().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop2().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getFlop1().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop2().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getFlop3().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop2().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getFlop3().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop2().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getTurn().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop3().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getFlop1().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getFlop2().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop3().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getFlop1().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop3().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getFlop1().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop3().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getFlop2().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop3().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getFlop2().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop3().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getTurn().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getTurn().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getFlop1().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getFlop2().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getTurn().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getFlop1().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getFlop3().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getTurn().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getFlop1().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getTurn().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getFlop2().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getFlop3().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getTurn().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getFlop2().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getTurn().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getFlop3().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getRiver().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getFlop1().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getFlop2().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getRiver().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getFlop1().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getFlop3().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getRiver().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getFlop1().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getRiver().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getFlop2().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getFlop3().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getRiver().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getFlop2().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getRiver().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getFlop3().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop1().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getFlop2().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getFlop3().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop1().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getFlop2().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop1().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getFlop2().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop1().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getFlop3().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop1().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getFlop3().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop1().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getTurn().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop2().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getFlop1().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getFlop3().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop2().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getFlop1().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop2().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getFlop1().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop2().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getFlop3().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop2().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getFlop3().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop2().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getTurn().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop3().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getFlop1().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getFlop2().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop3().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getFlop1().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop3().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getFlop1().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop3().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getFlop2().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop3().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getFlop2().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop3().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getTurn().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getTurn().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getFlop1().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getFlop2().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getTurn().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getFlop1().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getFlop3().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getTurn().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getFlop1().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getTurn().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getFlop2().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getFlop3().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getTurn().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getFlop2().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getTurn().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getFlop3().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getRiver().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getFlop1().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getFlop2().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getRiver().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getFlop1().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getFlop3().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getRiver().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getFlop1().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getRiver().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getFlop2().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getFlop3().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getRiver().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getFlop2().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getRiver().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getFlop3().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop1().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getFlop3().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop1().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getFlop3().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop1().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getTurn().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop1().getNombre()
                    && nouveau.getFlop3().getNombre() == nouveau.getTurn().getNombre()
                    && nouveau.getFlop3().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop2().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getFlop3().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop2().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getFlop3().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop2().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getTurn().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop2().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getTurn().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop3().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getFlop2().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop3().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getFlop2().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop3().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getTurn().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop3().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getTurn().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getTurn().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getFlop2().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getFlop3().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getTurn().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getFlop2().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getTurn().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getFlop3().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getTurn().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getFlop3().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getRiver().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getFlop2().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getFlop3().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getRiver().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getFlop2().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getRiver().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getFlop3().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getRiver().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getFlop3().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop1().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getFlop3().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop1().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getFlop3().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop1().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getTurn().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop1().getNombre()
                    && nouveau.getFlop3().getNombre() == nouveau.getTurn().getNombre()
                    && nouveau.getFlop3().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop2().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getFlop3().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop2().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getFlop3().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop2().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getTurn().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop2().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getTurn().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop3().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getFlop2().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop3().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getFlop2().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop3().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getTurn().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop3().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getTurn().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getTurn().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getFlop2().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getFlop3().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getTurn().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getFlop2().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getTurn().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getFlop3().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getTurn().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getFlop3().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getRiver().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getFlop2().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getFlop3().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getRiver().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getFlop2().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getRiver().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getFlop3().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getRiver().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getFlop3().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop1().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getFlop2().getNombre()
                    && nouveau.getFlop3().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop1().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getFlop2().getNombre()
                    && nouveau.getFlop3().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop1().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getFlop2().getNombre()
                    && nouveau.getTurn().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop1().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getFlop3().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop1().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getFlop3().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop1().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getFlop3().getNombre()
                    && nouveau.getTurn().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop1().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getTurn().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getFlop3().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop1().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getTurn().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop1().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getTurn().getNombre()
                    && nouveau.getFlop3().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop1().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getRiver().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getFlop3().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop1().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getRiver().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop1().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getRiver().getNombre()
                    && nouveau.getFlop3().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop2().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getFlop3().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop2().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getFlop3().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop2().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getFlop3().getNombre()
                    && nouveau.getTurn().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop2().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getTurn().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getFlop3().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop2().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getTurn().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop2().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getTurn().getNombre()
                    && nouveau.getFlop3().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop2().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getRiver().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getFlop3().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop2().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getRiver().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop2().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getRiver().getNombre()
                    && nouveau.getFlop3().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop3().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getTurn().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getFlop2().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop3().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getTurn().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop3().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getTurn().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop3().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getRiver().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getFlop2().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop3().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getRiver().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop3().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getRiver().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getTurn().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getRiver().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getFlop2().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getTurn().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getRiver().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getFlop3().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getTurn().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getRiver().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getFlop3().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop1().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getFlop2().getNombre()
                    && nouveau.getFlop3().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop1().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getFlop2().getNombre()
                    && nouveau.getFlop3().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop1().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getFlop2().getNombre()
                    && nouveau.getTurn().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop1().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getFlop3().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop1().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getFlop3().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop1().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getFlop3().getNombre()
                    && nouveau.getTurn().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop1().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getTurn().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getFlop3().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop1().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getTurn().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop1().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getTurn().getNombre()
                    && nouveau.getFlop3().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop1().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getRiver().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getFlop3().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop1().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getRiver().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop1().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getRiver().getNombre()
                    && nouveau.getFlop3().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop2().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getFlop3().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop2().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getFlop3().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop2().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getFlop3().getNombre()
                    && nouveau.getTurn().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop2().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getTurn().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getFlop3().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop2().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getTurn().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop2().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getTurn().getNombre()
                    && nouveau.getFlop3().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop2().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getRiver().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getFlop3().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop2().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getRiver().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop2().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getRiver().getNombre()
                    && nouveau.getFlop3().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop3().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getTurn().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getFlop2().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop3().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getTurn().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop3().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getTurn().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop3().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getRiver().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getFlop2().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop3().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getRiver().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop3().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getRiver().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getTurn().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getRiver().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getFlop2().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getTurn().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getRiver().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getFlop3().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getTurn().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getRiver().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getFlop3().getNombre())
                    || (nouveau.getFlop1().getNombre() == nouveau.getFlop2().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getFlop3().getNombre()
                    && nouveau.getTurn().getNombre() == nouveau.getRiver().getNombre())
                    || (nouveau.getFlop1().getNombre() == nouveau.getFlop2().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getTurn().getNombre()
                    && nouveau.getFlop3().getNombre() == nouveau.getRiver().getNombre())
                    || (nouveau.getFlop1().getNombre() == nouveau.getFlop2().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getRiver().getNombre()
                    && nouveau.getFlop3().getNombre() == nouveau.getTurn().getNombre())
                    || (nouveau.getFlop1().getNombre() == nouveau.getFlop3().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getTurn().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getRiver().getNombre())
                    || (nouveau.getFlop1().getNombre() == nouveau.getFlop3().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getRiver().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getTurn().getNombre())
                    || (nouveau.getFlop2().getNombre() == nouveau.getFlop3().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getTurn().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getRiver().getNombre())
                    || (nouveau.getFlop2().getNombre() == nouveau.getFlop3().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getRiver().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getTurn().getNombre())
                    || (nouveau.getFlop2().getNombre() == nouveau.getTurn().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getRiver().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getFlop3().getNombre())
                    || (nouveau.getFlop3().getNombre() == nouveau.getTurn().getNombre()
                    && nouveau.getFlop3().getNombre() == nouveau.getRiver().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getFlop2().getNombre())) {
                System.out.println("Joueur " + (i + 1) + ": Full House");
                joueurs[i].setPower(3);
            } else if ((joueurs[i].getHand0().getCouleur().equals(joueurs[i].getHand1().getCouleur())
                    && joueurs[i].getHand0().getCouleur().equals(nouveau.getFlop1().getCouleur())
                    && joueurs[i].getHand0().getCouleur().equals(nouveau.getFlop2().getCouleur())
                    && joueurs[i].getHand0().getCouleur().equals(nouveau.getFlop3().getCouleur()))
                    || (joueurs[i].getHand0().getCouleur().equals(joueurs[i].getHand1().getCouleur())
                    && joueurs[i].getHand0().getCouleur().equals(nouveau.getFlop1().getCouleur())
                    && joueurs[i].getHand0().getCouleur().equals(nouveau.getFlop2().getCouleur())
                    && joueurs[i].getHand0().getCouleur().equals(nouveau.getTurn().getCouleur()))
                    || (joueurs[i].getHand0().getCouleur().equals(joueurs[i].getHand1().getCouleur())
                    && joueurs[i].getHand0().getCouleur().equals(nouveau.getFlop1().getCouleur())
                    && joueurs[i].getHand0().getCouleur().equals(nouveau.getFlop2().getCouleur())
                    && joueurs[i].getHand0().getCouleur().equals(nouveau.getRiver().getCouleur()))
                    || (joueurs[i].getHand0().getCouleur().equals(joueurs[i].getHand1().getCouleur())
                    && joueurs[i].getHand0().getCouleur().equals(nouveau.getFlop1().getCouleur())
                    && joueurs[i].getHand0().getCouleur().equals(nouveau.getFlop3().getCouleur())
                    && joueurs[i].getHand0().getCouleur().equals(nouveau.getTurn().getCouleur()))
                    || (joueurs[i].getHand0().getCouleur().equals(joueurs[i].getHand1().getCouleur())
                    && joueurs[i].getHand0().getCouleur().equals(nouveau.getFlop1().getCouleur())
                    && joueurs[i].getHand0().getCouleur().equals(nouveau.getFlop3().getCouleur())
                    && joueurs[i].getHand0().getCouleur().equals(nouveau.getRiver().getCouleur()))
                    || (joueurs[i].getHand0().getCouleur().equals(joueurs[i].getHand1().getCouleur())
                    && joueurs[i].getHand0().getCouleur().equals(nouveau.getFlop1().getCouleur())
                    && joueurs[i].getHand0().getCouleur().equals(nouveau.getTurn().getCouleur())
                    && joueurs[i].getHand0().getCouleur().equals(nouveau.getRiver().getCouleur()))
                    || (joueurs[i].getHand0().getCouleur().equals(joueurs[i].getHand1().getCouleur())
                    && joueurs[i].getHand0().getCouleur().equals(nouveau.getFlop2().getCouleur())
                    && joueurs[i].getHand0().getCouleur().equals(nouveau.getFlop3().getCouleur())
                    && joueurs[i].getHand0().getCouleur().equals(nouveau.getTurn().getCouleur()))
                    || (joueurs[i].getHand0().getCouleur().equals(joueurs[i].getHand1().getCouleur())
                    && joueurs[i].getHand0().getCouleur().equals(nouveau.getFlop2().getCouleur())
                    && joueurs[i].getHand0().getCouleur().equals(nouveau.getFlop3().getCouleur())
                    && joueurs[i].getHand0().getCouleur().equals(nouveau.getRiver().getCouleur()))
                    || (joueurs[i].getHand0().getCouleur().equals(joueurs[i].getHand1().getCouleur())
                    && joueurs[i].getHand0().getCouleur().equals(nouveau.getFlop2().getCouleur())
                    && joueurs[i].getHand0().getCouleur().equals(nouveau.getTurn().getCouleur())
                    && joueurs[i].getHand0().getCouleur().equals(nouveau.getRiver().getCouleur()))
                    || (joueurs[i].getHand0().getCouleur().equals(joueurs[i].getHand1().getCouleur())
                    && joueurs[i].getHand0().getCouleur().equals(nouveau.getFlop3().getCouleur())
                    && joueurs[i].getHand0().getCouleur().equals(nouveau.getTurn().getCouleur())
                    && joueurs[i].getHand0().getCouleur().equals(nouveau.getRiver().getCouleur()))
                    || (joueurs[i].getHand0().getCouleur().equals(nouveau.getFlop1().getCouleur())
                    && joueurs[i].getHand0().getCouleur().equals(nouveau.getFlop2().getCouleur())
                    && joueurs[i].getHand0().getCouleur().equals(nouveau.getFlop3().getCouleur())
                    && joueurs[i].getHand0().getCouleur().equals(nouveau.getTurn().getCouleur()))
                    || (joueurs[i].getHand0().getCouleur().equals(nouveau.getFlop1().getCouleur())
                    && joueurs[i].getHand0().getCouleur().equals(nouveau.getFlop2().getCouleur())
                    && joueurs[i].getHand0().getCouleur().equals(nouveau.getFlop3().getCouleur())
                    && joueurs[i].getHand0().getCouleur().equals(nouveau.getRiver().getCouleur()))
                    || (joueurs[i].getHand0().getCouleur().equals(nouveau.getFlop1().getCouleur())
                    && joueurs[i].getHand0().getCouleur().equals(nouveau.getFlop2().getCouleur())
                    && joueurs[i].getHand0().getCouleur().equals(nouveau.getTurn().getCouleur())
                    && joueurs[i].getHand0().getCouleur().equals(nouveau.getRiver().getCouleur()))
                    || (joueurs[i].getHand0().getCouleur().equals(nouveau.getFlop1().getCouleur())
                    && joueurs[i].getHand0().getCouleur().equals(nouveau.getFlop3().getCouleur())
                    && joueurs[i].getHand0().getCouleur().equals(nouveau.getTurn().getCouleur())
                    && joueurs[i].getHand0().getCouleur().equals(nouveau.getRiver().getCouleur()))
                    || (joueurs[i].getHand0().getCouleur().equals(nouveau.getFlop2().getCouleur())
                    && joueurs[i].getHand0().getCouleur().equals(nouveau.getFlop3().getCouleur())
                    && joueurs[i].getHand0().getCouleur().equals(nouveau.getTurn().getCouleur())
                    && joueurs[i].getHand0().getCouleur().equals(nouveau.getRiver().getCouleur()))
                    || (joueurs[i].getHand1().getCouleur().equals(nouveau.getFlop1().getCouleur())
                    && joueurs[i].getHand1().getCouleur().equals(nouveau.getFlop2().getCouleur())
                    && joueurs[i].getHand1().getCouleur().equals(nouveau.getFlop3().getCouleur())
                    && joueurs[i].getHand1().getCouleur().equals(nouveau.getTurn().getCouleur()))
                    || (joueurs[i].getHand1().getCouleur().equals(nouveau.getFlop1().getCouleur())
                    && joueurs[i].getHand1().getCouleur().equals(nouveau.getFlop2().getCouleur())
                    && joueurs[i].getHand1().getCouleur().equals(nouveau.getFlop3().getCouleur())
                    && joueurs[i].getHand1().getCouleur().equals(nouveau.getRiver().getCouleur()))
                    || (joueurs[i].getHand1().getCouleur().equals(nouveau.getFlop1().getCouleur())
                    && joueurs[i].getHand1().getCouleur().equals(nouveau.getFlop2().getCouleur())
                    && joueurs[i].getHand1().getCouleur().equals(nouveau.getTurn().getCouleur())
                    && joueurs[i].getHand1().getCouleur().equals(nouveau.getRiver().getCouleur()))
                    || (joueurs[i].getHand1().getCouleur().equals(nouveau.getFlop1().getCouleur())
                    && joueurs[i].getHand1().getCouleur().equals(nouveau.getFlop3().getCouleur())
                    && joueurs[i].getHand1().getCouleur().equals(nouveau.getTurn().getCouleur())
                    && joueurs[i].getHand1().getCouleur().equals(nouveau.getRiver().getCouleur()))
                    || (joueurs[i].getHand1().getCouleur().equals(nouveau.getFlop2().getCouleur())
                    && joueurs[i].getHand1().getCouleur().equals(nouveau.getFlop3().getCouleur())
                    && joueurs[i].getHand1().getCouleur().equals(nouveau.getTurn().getCouleur())
                    && joueurs[i].getHand1().getCouleur().equals(nouveau.getRiver().getCouleur()))
                    || (nouveau.getFlop1().getCouleur().equals(nouveau.getFlop2().getCouleur())
                    && nouveau.getFlop1().getCouleur().equals(nouveau.getFlop3().getCouleur())
                    && nouveau.getFlop1().getCouleur().equals(nouveau.getTurn().getCouleur())
                    && nouveau.getFlop1().getCouleur().equals(nouveau.getRiver().getCouleur()))) {
                System.out.println("Joueur " + (i + 1) + ": Flush");
                joueurs[i].setPower(4);

            } else if (((tableauStraight[i][0] == 2) && (tableauStraight[i][1] == 3)
                    && (tableauStraight[i][2] == 4) && (tableauStraight[i][3] == 5)
                    && ((tableauStraight[i][4] == 14) || (tableauStraight[i][5] == 14)
                    || (tableauStraight[i][6] == 14)))
                    || ((tableauStraight[i][0] == 2) && (tableauStraight[i][1] == 3)
                    && (tableauStraight[i][2] == 4) && (tableauStraight[i][3] == 5)
                    && ((tableauStraight[i][4] == 6) || (tableauStraight[i][5] == 6)
                    || (tableauStraight[i][6] == 6)))
                    || ((tableauStraight[i][0] == 3) && (tableauStraight[i][1] == 4)
                    && (tableauStraight[i][2] == 5) && (tableauStraight[i][3] == 6)
                    && ((tableauStraight[i][4] == 7) || (tableauStraight[i][5] == 7)
                    || (tableauStraight[i][6] == 7)))
                    || ((tableauStraight[i][0] == 4) && (tableauStraight[i][1] == 5)
                    && (tableauStraight[i][2] == 6) && (tableauStraight[i][3] == 7)
                    && (tableauStraight[i][4] == 8))
                    || ((tableauStraight[i][1] == 4) && (tableauStraight[i][2] == 5)
                    && (tableauStraight[i][3] == 6) && (tableauStraight[i][4] == 7)
                    && (tableauStraight[i][5] == 8))
                    || ((tableauStraight[i][2] == 4) && (tableauStraight[i][3] == 5)
                    && (tableauStraight[i][4] == 6) && (tableauStraight[i][5] == 7)
                    && (tableauStraight[i][6] == 8))
                    || ((tableauStraight[i][0] == 5) && (tableauStraight[i][1] == 6)
                    && (tableauStraight[i][2] == 7) && (tableauStraight[i][3] == 8)
                    && (tableauStraight[i][4] == 9))
                    || ((tableauStraight[i][1] == 5) && (tableauStraight[i][2] == 6)
                    && (tableauStraight[i][3] == 7) && (tableauStraight[i][4] == 8)
                    && (tableauStraight[i][5] == 9))
                    || ((tableauStraight[i][2] == 5) && (tableauStraight[i][3] == 6)
                    && (tableauStraight[i][4] == 7) && (tableauStraight[i][5] == 8)
                    && (tableauStraight[i][6] == 9))
                    || ((tableauStraight[i][0] == 6) && (tableauStraight[i][1] == 7)
                    && (tableauStraight[i][2] == 8) && (tableauStraight[i][3] == 9)
                    && (tableauStraight[i][4] == 10))
                    || ((tableauStraight[i][1] == 6) && (tableauStraight[i][2] == 7)
                    && (tableauStraight[i][3] == 8) && (tableauStraight[i][4] == 9)
                    && (tableauStraight[i][5] == 10))
                    || ((tableauStraight[i][2] == 6) && (tableauStraight[i][3] == 7)
                    && (tableauStraight[i][4] == 8) && (tableauStraight[i][5] == 9)
                    && (tableauStraight[i][6] == 10))
                    || ((tableauStraight[i][0] == 7) && (tableauStraight[i][1] == 8)
                    && (tableauStraight[i][2] == 9) && (tableauStraight[i][3] == 10)
                    && (tableauStraight[i][4] == 11))
                    || ((tableauStraight[i][1] == 7) && (tableauStraight[i][2] == 8)
                    && (tableauStraight[i][3] == 9) && (tableauStraight[i][4] == 10)
                    && (tableauStraight[i][5] == 11))
                    || ((tableauStraight[i][2] == 7) && (tableauStraight[i][3] == 8)
                    && (tableauStraight[i][4] == 9) && (tableauStraight[i][5] == 10)
                    && (tableauStraight[i][6] == 11))
                    || ((tableauStraight[i][0] == 8) && (tableauStraight[i][1] == 9)
                    && (tableauStraight[i][2] == 10) && (tableauStraight[i][3] == 11)
                    && (tableauStraight[i][4] == 12))
                    || ((tableauStraight[i][1] == 8) && (tableauStraight[i][2] == 9)
                    && (tableauStraight[i][3] == 10) && (tableauStraight[i][4] == 11)
                    && (tableauStraight[i][5] == 12))
                    || ((tableauStraight[i][2] == 8) && (tableauStraight[i][3] == 9)
                    && (tableauStraight[i][4] == 10) && (tableauStraight[i][5] == 11)
                    && (tableauStraight[i][6] == 12))
                    || ((tableauStraight[i][0] == 9) && (tableauStraight[i][1] == 10)
                    && (tableauStraight[i][2] == 11) && (tableauStraight[i][3] == 12)
                    && (tableauStraight[i][4] == 13))
                    || ((tableauStraight[i][1] == 9) && (tableauStraight[i][2] == 10)
                    && (tableauStraight[i][3] == 11) && (tableauStraight[i][4] == 12)
                    && (tableauStraight[i][5] == 13))
                    || ((tableauStraight[i][2] == 9) && (tableauStraight[i][3] == 10)
                    && (tableauStraight[i][4] == 11) && (tableauStraight[i][5] == 12)
                    && (tableauStraight[i][6] == 13))
                    || ((tableauStraight[i][0] == 10) && (tableauStraight[i][1] == 11)
                    && (tableauStraight[i][2] == 12) && (tableauStraight[i][3] == 13)
                    && (tableauStraight[i][4] == 14))
                    || ((tableauStraight[i][1] == 10) && (tableauStraight[i][2] == 11)
                    && (tableauStraight[i][3] == 12) && (tableauStraight[i][4] == 13)
                    && (tableauStraight[i][5] == 14))
                    || ((tableauStraight[i][2] == 10) && (tableauStraight[i][3] == 11)
                    && (tableauStraight[i][4] == 12) && (tableauStraight[i][5] == 13)
                    && (tableauStraight[i][6] == 14))) {
                System.out.println("Joueur " + (i + 1) + ": Straight");
                joueurs[i].setPower(5);
            } else if ((joueurs[i].getHand0().getNombre() == joueurs[i].getHand1().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getFlop1().getNombre())
                    || (joueurs[i].getHand0().getNombre() == joueurs[i].getHand1().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getFlop2().getNombre())
                    || (joueurs[i].getHand0().getNombre() == joueurs[i].getHand1().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getFlop3().getNombre())
                    || (joueurs[i].getHand0().getNombre() == joueurs[i].getHand1().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand0().getNombre() == joueurs[i].getHand1().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop1().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getFlop2().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop1().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getFlop3().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop1().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop1().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop2().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getFlop3().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop2().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop2().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop3().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop3().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getTurn().getNombre()
                    && joueurs[i].getHand0().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop1().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getFlop2().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop1().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getFlop3().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop1().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop1().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop2().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getFlop3().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop2().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop2().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop3().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop3().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getTurn().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getRiver().getNombre())
                    || (nouveau.getFlop1().getNombre() == nouveau.getFlop2().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getFlop3().getNombre())
                    || (nouveau.getFlop1().getNombre() == nouveau.getFlop2().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getTurn().getNombre())
                    || (nouveau.getFlop1().getNombre() == nouveau.getFlop2().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getRiver().getNombre())
                    || (nouveau.getFlop1().getNombre() == nouveau.getFlop3().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getTurn().getNombre())
                    || (nouveau.getFlop1().getNombre() == nouveau.getFlop3().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getRiver().getNombre())
                    || (nouveau.getFlop1().getNombre() == nouveau.getTurn().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getRiver().getNombre())
                    || (nouveau.getFlop2().getNombre() == nouveau.getFlop3().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getTurn().getNombre())
                    || (nouveau.getFlop2().getNombre() == nouveau.getFlop3().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getRiver().getNombre())
                    || (nouveau.getFlop2().getNombre() == nouveau.getTurn().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getRiver().getNombre())
                    || (nouveau.getFlop3().getNombre() == nouveau.getTurn().getNombre()
                    && nouveau.getFlop3().getNombre() == nouveau.getRiver().getNombre())) {
                System.out.println("Joueur " + (i + 1) + ": Brelan");
                joueurs[i].setPower(6);
            } else if ((joueurs[i].getHand0().getNombre() == joueurs[i].getHand1().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getFlop2().getNombre())
                    || (joueurs[i].getHand0().getNombre() == joueurs[i].getHand1().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getFlop3().getNombre())
                    || (joueurs[i].getHand0().getNombre() == joueurs[i].getHand1().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand0().getNombre() == joueurs[i].getHand1().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == joueurs[i].getHand1().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getFlop3().getNombre())
                    || (joueurs[i].getHand0().getNombre() == joueurs[i].getHand1().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand0().getNombre() == joueurs[i].getHand1().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == joueurs[i].getHand1().getNombre()
                    && nouveau.getFlop3().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand0().getNombre() == joueurs[i].getHand1().getNombre()
                    && nouveau.getFlop3().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == joueurs[i].getHand1().getNombre()
                    && nouveau.getTurn().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop1().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getFlop3().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop1().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop1().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop1().getNombre()
                    && nouveau.getFlop3().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop1().getNombre()
                    && nouveau.getFlop3().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop1().getNombre()
                    && nouveau.getTurn().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop2().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getFlop3().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop2().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop2().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop2().getNombre()
                    && nouveau.getFlop3().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop2().getNombre()
                    && nouveau.getFlop3().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop2().getNombre()
                    && nouveau.getTurn().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop3().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getFlop2().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop3().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop3().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop3().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop3().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop3().getNombre()
                    && nouveau.getTurn().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getTurn().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getFlop2().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getTurn().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getFlop3().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getTurn().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getTurn().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getFlop3().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getTurn().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getTurn().getNombre()
                    && nouveau.getFlop3().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getRiver().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getFlop2().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getRiver().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getFlop3().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getRiver().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getRiver().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getFlop3().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getRiver().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getRiver().getNombre()
                    && nouveau.getFlop3().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop1().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getFlop3().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop1().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop1().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop1().getNombre()
                    && nouveau.getFlop3().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop1().getNombre()
                    && nouveau.getFlop3().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop1().getNombre()
                    && nouveau.getTurn().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop2().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getFlop3().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop2().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop2().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop2().getNombre()
                    && nouveau.getFlop3().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop2().getNombre()
                    && nouveau.getFlop3().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop2().getNombre()
                    && nouveau.getTurn().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop3().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getFlop2().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop3().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop3().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop3().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop3().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getFlop3().getNombre()
                    && nouveau.getTurn().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getTurn().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getFlop2().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getTurn().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getFlop3().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getTurn().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getTurn().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getFlop3().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getTurn().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getTurn().getNombre()
                    && nouveau.getFlop3().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getRiver().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getFlop2().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getRiver().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getFlop3().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getRiver().getNombre()
                    && nouveau.getFlop1().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getRiver().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getFlop3().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getRiver().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand1().getNombre() == nouveau.getRiver().getNombre()
                    && nouveau.getFlop3().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop1().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getFlop2().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop1().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getFlop3().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop1().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop1().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop2().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getFlop1().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop2().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getFlop3().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop2().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop2().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop3().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getFlop1().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop3().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getFlop2().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop3().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getTurn().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getFlop3().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getTurn().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getFlop1().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getTurn().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getFlop2().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getTurn().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getFlop3().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getTurn().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getRiver().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getRiver().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getFlop1().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getRiver().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getFlop2().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getRiver().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getFlop3().getNombre())
                    || (joueurs[i].getHand0().getNombre() == nouveau.getRiver().getNombre()
                    && joueurs[i].getHand1().getNombre() == nouveau.getTurn().getNombre())
                    || (nouveau.getFlop1().getNombre() == nouveau.getFlop2().getNombre()
                    && nouveau.getFlop3().getNombre() == nouveau.getTurn().getNombre())
                    || (nouveau.getFlop1().getNombre() == nouveau.getFlop2().getNombre()
                    && nouveau.getFlop3().getNombre() == nouveau.getRiver().getNombre())
                    || (nouveau.getFlop1().getNombre() == nouveau.getFlop2().getNombre()
                    && nouveau.getTurn().getNombre() == nouveau.getRiver().getNombre())
                    || (nouveau.getFlop1().getNombre() == nouveau.getFlop3().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getTurn().getNombre())
                    || (nouveau.getFlop1().getNombre() == nouveau.getFlop3().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getRiver().getNombre())
                    || (nouveau.getFlop1().getNombre() == nouveau.getFlop3().getNombre()
                    && nouveau.getTurn().getNombre() == nouveau.getRiver().getNombre())
                    || (nouveau.getFlop1().getNombre() == nouveau.getTurn().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getFlop3().getNombre())
                    || (nouveau.getFlop1().getNombre() == nouveau.getTurn().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getRiver().getNombre())
                    || (nouveau.getFlop1().getNombre() == nouveau.getTurn().getNombre()
                    && nouveau.getFlop3().getNombre() == nouveau.getRiver().getNombre())
                    || (nouveau.getFlop1().getNombre() == nouveau.getRiver().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getFlop3().getNombre())
                    || (nouveau.getFlop1().getNombre() == nouveau.getRiver().getNombre()
                    && nouveau.getFlop2().getNombre() == nouveau.getTurn().getNombre())
                    || (nouveau.getFlop1().getNombre() == nouveau.getRiver().getNombre()
                    && nouveau.getFlop3().getNombre() == nouveau.getTurn().getNombre())
                    || (nouveau.getFlop2().getNombre() == nouveau.getFlop3().getNombre()
                    && nouveau.getTurn().getNombre() == nouveau.getRiver().getNombre())
                    || (nouveau.getFlop2().getNombre() == nouveau.getTurn().getNombre()
                    && nouveau.getFlop3().getNombre() == nouveau.getRiver().getNombre())
                    || (nouveau.getFlop2().getNombre() == nouveau.getRiver().getNombre()
                    && nouveau.getFlop3().getNombre() == nouveau.getTurn().getNombre())) {
                System.out.println("Joueur " + (i + 1) + ": Two pairs");
                joueurs[i].setPower(7);

            } else if (joueurs[i].getHand0().getNombre() == joueurs[i].getHand1().getNombre()
                    || joueurs[i].getHand0().getNombre() == nouveau.getFlop1().getNombre()
                    || joueurs[i].getHand0().getNombre() == nouveau.getFlop2().getNombre()
                    || joueurs[i].getHand0().getNombre() == nouveau.getFlop3().getNombre()
                    || joueurs[i].getHand0().getNombre() == nouveau.getTurn().getNombre()
                    || joueurs[i].getHand0().getNombre() == nouveau.getRiver().getNombre()
                    || joueurs[i].getHand1().getNombre() == nouveau.getFlop1().getNombre()
                    || joueurs[i].getHand1().getNombre() == nouveau.getFlop2().getNombre()
                    || joueurs[i].getHand1().getNombre() == nouveau.getFlop3().getNombre()
                    || joueurs[i].getHand1().getNombre() == nouveau.getTurn().getNombre()
                    || joueurs[i].getHand1().getNombre() == nouveau.getRiver().getNombre()
                    || nouveau.getFlop1().getNombre() == nouveau.getFlop2().getNombre()
                    || nouveau.getFlop1().getNombre() == nouveau.getFlop3().getNombre()
                    || nouveau.getFlop1().getNombre() == nouveau.getTurn().getNombre()
                    || nouveau.getFlop1().getNombre() == nouveau.getRiver().getNombre()
                    || nouveau.getFlop2().getNombre() == nouveau.getFlop3().getNombre()
                    || nouveau.getFlop2().getNombre() == nouveau.getTurn().getNombre()
                    || nouveau.getFlop2().getNombre() == nouveau.getRiver().getNombre()
                    || nouveau.getFlop3().getNombre() == nouveau.getTurn().getNombre()
                    || nouveau.getFlop3().getNombre() == nouveau.getRiver().getNombre()
                    || nouveau.getTurn().getNombre() == nouveau.getRiver().getNombre()) {
                System.out.println("Joueur " + (i + 1) + ": Pair");
                joueurs[i].setPower(8);
            } else {
                if (tableau1[i][6] == 14) {
                    System.out.println("Joueur " + (i + 1) + ": Ace High");
                    joueurs[i].setPower(9);
                } else if (tableau1[i][6] == 13) {
                    System.out.println("Joueur " + (i + 1) + ": King High");
                    joueurs[i].setPower(10);
                } else if (tableau1[i][6] == 12) {
                    System.out.println("Joueur " + (i + 1) + ": Queen High");
                    joueurs[i].setPower(11);
                } else if (tableau1[i][6] == 11) {
                    System.out.println("Joueur " + (i + 1) + ": Jack High");
                    joueurs[i].setPower(12);
                } else if (tableau1[i][6] == 10) {
                    System.out.println("Joueur " + (i + 1) + ": Ten High");
                    joueurs[i].setPower(13);
                } else if (tableau1[i][6] == 9) {
                    System.out.println("Joueur " + (i + 1) + ": Nine High");
                    joueurs[i].setPower(14);
                } else if (tableau1[i][6] == 8) {
                    System.out.println("Joueur " + (i + 1) + ": Eight High");
                    joueurs[i].setPower(15);
                } else if (tableau1[i][6] == 7) {
                    System.out.println("Joueur " + (i + 1) + ": Seven High");
                    joueurs[i].setPower(16);
                } else if (tableau1[i][6] == 6) {
                    System.out.println("Joueur " + (i + 1) + ": Six High");
                    joueurs[i].setPower(17);
                }
            }
        }
        boolean joueur1 = false;
        boolean joueur2 = false;
        boolean joueur3 = false;
        boolean joueur4 = false;
        boolean joueur5 = false;
        boolean joueur6 = false;
        boolean joueur7 = false;
        int totalSplitPot = 0;
        if ((joueurs[0].getPower() < joueurs[1].getPower())
                && (joueurs[0].getPower() < joueurs[2].getPower())
                && (joueurs[0].getPower() < joueurs[3].getPower())
                && (joueurs[0].getPower() < joueurs[4].getPower())
                && (joueurs[0].getPower() < joueurs[5].getPower())
                && (joueurs[0].getPower() < joueurs[6].getPower())) {
            System.out.println("Player 1 has the best hand and wins the pot! (" + frame.miseTotal + "$)");
        } else if ((joueurs[1].getPower() < joueurs[0].getPower())
                && (joueurs[1].getPower() < joueurs[2].getPower())
                && (joueurs[1].getPower() < joueurs[3].getPower())
                && (joueurs[1].getPower() < joueurs[4].getPower())
                && (joueurs[1].getPower() < joueurs[5].getPower())
                && (joueurs[1].getPower() < joueurs[6].getPower())) {
            System.out.println("Player 2 has the best hand and wins the pot! (" + frame.miseTotal + "$)");
        } else if ((joueurs[2].getPower() < joueurs[0].getPower())
                && (joueurs[2].getPower() < joueurs[1].getPower())
                && (joueurs[2].getPower() < joueurs[3].getPower())
                && (joueurs[2].getPower() < joueurs[4].getPower())
                && (joueurs[2].getPower() < joueurs[5].getPower())
                && (joueurs[2].getPower() < joueurs[6].getPower())) {
            System.out.println("Player 3 has the best hand and wins the pot! (" + frame.miseTotal + "$)");
        } else if ((joueurs[3].getPower() < joueurs[0].getPower())
                && (joueurs[3].getPower() < joueurs[1].getPower())
                && (joueurs[3].getPower() < joueurs[2].getPower())
                && (joueurs[3].getPower() < joueurs[4].getPower())
                && (joueurs[3].getPower() < joueurs[5].getPower())
                && (joueurs[3].getPower() < joueurs[6].getPower())) {
            System.out.println("Player 4 has the best hand and wins the pot! (" + frame.miseTotal + "$)");
        } else if ((joueurs[4].getPower() < joueurs[0].getPower())
                && (joueurs[4].getPower() < joueurs[1].getPower())
                && (joueurs[4].getPower() < joueurs[2].getPower())
                && (joueurs[4].getPower() < joueurs[3].getPower())
                && (joueurs[4].getPower() < joueurs[5].getPower())
                && (joueurs[4].getPower() < joueurs[6].getPower())) {
            System.out.println("Player 5 has the best hand and wins the pot! (" + frame.miseTotal + "$)");
        } else if ((joueurs[5].getPower() < joueurs[0].getPower())
                && (joueurs[5].getPower() < joueurs[1].getPower())
                && (joueurs[5].getPower() < joueurs[2].getPower())
                && (joueurs[5].getPower() < joueurs[3].getPower())
                && (joueurs[5].getPower() < joueurs[4].getPower())
                && (joueurs[5].getPower() < joueurs[6].getPower())) {
            System.out.println("Player 6 has the best hand and wins the pot! (" + frame.miseTotal + "$)");
        } else if ((joueurs[6].getPower() < joueurs[0].getPower())
                && (joueurs[6].getPower() < joueurs[1].getPower())
                && (joueurs[6].getPower() < joueurs[2].getPower())
                && (joueurs[6].getPower() < joueurs[3].getPower())
                && (joueurs[6].getPower() < joueurs[4].getPower())
                && (joueurs[6].getPower() < joueurs[5].getPower())) {
            System.out.println("Player 7 has the best hand and wins the pot! (" + frame.miseTotal + "$)");
        } else {
            System.out.println("Split Pot!");
            if ((joueurs[0].getPower() <= joueurs[1].getPower())
                    && (joueurs[0].getPower() <= joueurs[2].getPower())
                    && (joueurs[0].getPower() <= joueurs[3].getPower())
                    && (joueurs[0].getPower() <= joueurs[4].getPower())
                    && (joueurs[0].getPower() <= joueurs[5].getPower())
                    && (joueurs[0].getPower() <= joueurs[6].getPower())) {
                joueur1 = true;
                totalSplitPot++;
            } if ((joueurs[1].getPower() <= joueurs[0].getPower())
                    && (joueurs[1].getPower() <= joueurs[2].getPower())
                    && (joueurs[1].getPower() <= joueurs[3].getPower())
                    && (joueurs[1].getPower() <= joueurs[4].getPower())
                    && (joueurs[1].getPower() <= joueurs[5].getPower())
                    && (joueurs[1].getPower() <= joueurs[6].getPower())) {
                joueur2 = true;
                totalSplitPot++;
            } if ((joueurs[2].getPower() <= joueurs[0].getPower())
                    && (joueurs[2].getPower() <= joueurs[1].getPower())
                    && (joueurs[2].getPower() <= joueurs[3].getPower())
                    && (joueurs[2].getPower() <= joueurs[4].getPower())
                    && (joueurs[2].getPower() <= joueurs[5].getPower())
                    && (joueurs[2].getPower() <= joueurs[6].getPower())) {
                joueur3 = true;
                totalSplitPot++;
            } if ((joueurs[3].getPower() <= joueurs[0].getPower())
                    && (joueurs[3].getPower() <= joueurs[1].getPower())
                    && (joueurs[3].getPower() <= joueurs[2].getPower())
                    && (joueurs[3].getPower() <= joueurs[4].getPower())
                    && (joueurs[3].getPower() <= joueurs[5].getPower())
                    && (joueurs[3].getPower() <= joueurs[6].getPower())) {
                joueur4 = true;
                totalSplitPot++;
            } if ((joueurs[4].getPower() <= joueurs[0].getPower())
                    && (joueurs[4].getPower() <= joueurs[1].getPower())
                    && (joueurs[4].getPower() <= joueurs[2].getPower())
                    && (joueurs[4].getPower() <= joueurs[3].getPower())
                    && (joueurs[4].getPower() <= joueurs[5].getPower())
                    && (joueurs[4].getPower() <= joueurs[6].getPower())) {
                joueur5 = true;
                totalSplitPot++;
            } if ((joueurs[5].getPower() <= joueurs[0].getPower())
                    && (joueurs[5].getPower() <= joueurs[1].getPower())
                    && (joueurs[5].getPower() <= joueurs[2].getPower())
                    && (joueurs[5].getPower() <= joueurs[3].getPower())
                    && (joueurs[5].getPower() <= joueurs[4].getPower())
                    && (joueurs[5].getPower() <= joueurs[6].getPower())) {
                joueur6 = true;
                totalSplitPot++;
            } if ((joueurs[6].getPower() <= joueurs[0].getPower())
                    && (joueurs[6].getPower() <= joueurs[1].getPower())
                    && (joueurs[6].getPower() <= joueurs[2].getPower())
                    && (joueurs[6].getPower() <= joueurs[3].getPower())
                    && (joueurs[6].getPower() <= joueurs[4].getPower())
                    && (joueurs[6].getPower() <= joueurs[5].getPower())) {
                joueur7 = true;
                totalSplitPot++;
            }
            if(joueur1 == true)
            {
                System.out.println("Player 1 wins 1/" + totalSplitPot + " of the pot(" + frame.miseTotal/totalSplitPot + "$)!");
            }
            if(joueur2 == true)
            {
                System.out.println("Player 2 wins 1/" + totalSplitPot + " of the pot(" + frame.miseTotal/totalSplitPot + "$)!");
            }
            if(joueur3 == true)
            {
                System.out.println("Player 3 wins 1/" + totalSplitPot + " of the pot(" + frame.miseTotal/totalSplitPot + "$)!");
            }
            if(joueur4 == true)
            {
                System.out.println("Player 4 wins 1/" + totalSplitPot + " of the pot(" + frame.miseTotal/totalSplitPot + "$)!");
            }
            if(joueur5 == true)
            {
                System.out.println("Player 5 wins 1/" + totalSplitPot + " of the pot(" + frame.miseTotal/totalSplitPot + "$)!");
            }
            if(joueur6 == true)
            {
                System.out.println("Player 6 wins 1/" + totalSplitPot + " of the pot(" + frame.miseTotal/totalSplitPot + "$)!");
            }
            if(joueur7 == true)
            {
                System.out.println("Player 7 wins 1/" + totalSplitPot + " of the pot(" + frame.miseTotal/totalSplitPot + "$)!");
            }
        }
    }

    @Override
    public void actionPerformed(ActionEvent e) {

        if (e.getSource() == timer) {
            repaint();
        }
    }

    @Override
    public void paintComponent(Graphics g) {
        super.paintComponent(g);

        g.drawImage(IMAGE_TABLE, 0, 0, null);
        g.drawImage(IMAGE_PILE, 400, 250, null);
        g.drawImage(JETON, 200, 125, null);
        g.drawImage(JETON, 150, 245, null);
        g.drawImage(JETON, 260, 335, null);
        g.drawImage(JETON, 420, 335, null);
        g.drawImage(JETON, 580, 335, null);
        g.drawImage(JETON, 686, 245, null);
        g.drawImage(JETON, 635, 125, null);

        if (quadrant1 == true && quadrant2 == false && quadrant3 == false && quadrant4 == false) {
            if (joueurs[z].getHand0().getPositionX() < tableauPositionHand0[z][0] && joueurs[z].getHand0().getPositionY() > tableauPositionHand0[z][1] && z == x) {
                g.drawImage(joueurs[z].getHand0().getImage(), joueurs[z].getHand0().getPositionX(), joueurs[z].getHand0().getPositionY(), null);
                modPositionCartesHand0(z);
            } else if (joueurs[x].getHand1().getPositionX() < tableauPositionHand1[x][0] && joueurs[x].getHand1().getPositionY() > tableauPositionHand1[x][1] && z > x) {
                g.drawImage(joueurs[x].getHand1().getImage(), joueurs[x].getHand1().getPositionX(), joueurs[x].getHand1().getPositionY(), null);
                modPositionCartesHand1(x);
            } else {
                if (z > x) {
                    joueurs[x].getHand1().setPositionX(tableauPositionHand1[x][0]);
                    joueurs[x].getHand1().setPositionY(tableauPositionHand1[x][1]);
                    g.drawImage(joueurs[x].getHand1().getImage(), joueurs[x].getHand1().getPositionX(), joueurs[x].getHand1().getPositionY(), null);
                    addition1 = 0;
                    addition2 = 0;
                    if (x < 6) {
                        x++;
                        checkQuadrant(z);
                    } else {
                        timer.stop();
                    }
                } else if (z == x) {
                    joueurs[z].getHand0().setPositionX(tableauPositionHand0[x][0]);
                    joueurs[z].getHand0().setPositionY(tableauPositionHand0[x][1]);
                    g.drawImage(joueurs[z].getHand0().getImage(), joueurs[z].getHand0().getPositionX(), joueurs[z].getHand0().getPositionY(), null);
                    addition1 = 0;
                    addition2 = 0;
                    if (z < 6) {
                        z++;
                        checkQuadrant(x);
                    }
                }
            }
        } else if (quadrant1 == false && quadrant2 == true && quadrant3 == false && quadrant4 == false) {
            if (joueurs[z].getHand0().getPositionX() > tableauPositionHand0[z][0] && joueurs[z].getHand0().getPositionY() > tableauPositionHand0[z][1] && z == x) {
                g.drawImage(joueurs[z].getHand0().getImage(), joueurs[z].getHand0().getPositionX(), joueurs[z].getHand0().getPositionY(), null);
                modPositionCartesHand0(z);
            } else if (joueurs[x].getHand1().getPositionX() > tableauPositionHand1[x][0] && joueurs[x].getHand1().getPositionY() > tableauPositionHand1[x][1] && z > x) {
                g.drawImage(joueurs[x].getHand1().getImage(), joueurs[x].getHand1().getPositionX(), joueurs[x].getHand1().getPositionY(), null);
                modPositionCartesHand1(x);
            } else {
                if (z > x) {
                    joueurs[x].getHand1().setPositionX(tableauPositionHand1[x][0]);
                    joueurs[x].getHand1().setPositionY(tableauPositionHand1[x][1]);
                    g.drawImage(joueurs[x].getHand1().getImage(), joueurs[x].getHand1().getPositionX(), joueurs[x].getHand1().getPositionY(), null);
                    addition1 = 0;
                    addition2 = 0;
                    if (x < 6) {
                        x++;
                        checkQuadrant(z);
                    } else {
                        timer.stop();
                    }
                } else if (z == x) {
                    joueurs[z].getHand0().setPositionX(tableauPositionHand0[x][0]);
                    joueurs[z].getHand0().setPositionY(tableauPositionHand0[x][1]);
                    g.drawImage(joueurs[z].getHand0().getImage(), joueurs[z].getHand0().getPositionX(), joueurs[z].getHand0().getPositionY(), null);
                    addition1 = 0;
                    addition2 = 0;
                    if (z < 6) {
                        z++;
                        checkQuadrant(x);
                    }
                }
            }
        } else if (quadrant1 == false && quadrant2 == false && quadrant3 == true && quadrant4 == false) {
            if (joueurs[z].getHand0().getPositionX() > tableauPositionHand0[z][0] && joueurs[z].getHand0().getPositionY() < tableauPositionHand0[z][1] && z == x) {
                g.drawImage(joueurs[z].getHand0().getImage(), joueurs[z].getHand0().getPositionX(), joueurs[z].getHand0().getPositionY(), null);
                modPositionCartesHand0(z);
            } else if (joueurs[x].getHand1().getPositionX() > tableauPositionHand1[x][0] && joueurs[x].getHand1().getPositionY() < tableauPositionHand1[x][1] && z > x) {
                g.drawImage(joueurs[x].getHand1().getImage(), joueurs[x].getHand1().getPositionX(), joueurs[x].getHand1().getPositionY(), null);
                modPositionCartesHand1(x);
            } else {
                if (z > x) {
                    joueurs[x].getHand1().setPositionX(tableauPositionHand1[x][0]);
                    joueurs[x].getHand1().setPositionY(tableauPositionHand1[x][1]);
                    g.drawImage(joueurs[x].getHand1().getImage(), joueurs[x].getHand1().getPositionX(), joueurs[x].getHand1().getPositionY(), null);
                    addition1 = 0;
                    addition2 = 0;
                    if (x < 6) {
                        x++;
                        checkQuadrant(z);
                    } else {
                        timer.stop();
                    }
                } else if (z == x) {
                    joueurs[z].getHand0().setPositionX(tableauPositionHand0[x][0]);
                    joueurs[z].getHand0().setPositionY(tableauPositionHand0[x][1]);
                    g.drawImage(joueurs[z].getHand0().getImage(), joueurs[z].getHand0().getPositionX(), joueurs[z].getHand0().getPositionY(), null);
                    addition1 = 0;
                    addition2 = 0;
                    if (z < 6) {
                        z++;
                        checkQuadrant(x);
                    }
                }
            }
        } else if (quadrant1 == false && quadrant2 == false && quadrant3 == false && quadrant4 == true) {
            if (joueurs[z].getHand0().getPositionX() < tableauPositionHand0[z][0] && joueurs[z].getHand0().getPositionY() < tableauPositionHand0[z][1] && z == x) {
                g.drawImage(joueurs[z].getHand0().getImage(), joueurs[z].getHand0().getPositionX(), joueurs[z].getHand0().getPositionY(), null);
                modPositionCartesHand0(z);
            } else if (joueurs[x].getHand1().getPositionX() < tableauPositionHand1[x][0] && joueurs[x].getHand1().getPositionY() < tableauPositionHand1[x][1] && z > x) {
                g.drawImage(joueurs[x].getHand1().getImage(), joueurs[x].getHand1().getPositionX(), joueurs[x].getHand1().getPositionY(), null);
                modPositionCartesHand1(x);
            } else {
                if (z > x) {
                    joueurs[x].getHand1().setPositionX(tableauPositionHand1[x][0]);
                    joueurs[x].getHand1().setPositionY(tableauPositionHand1[x][1]);
                    g.drawImage(joueurs[x].getHand1().getImage(), joueurs[x].getHand1().getPositionX(), joueurs[x].getHand1().getPositionY(), null);
                    addition1 = 0;
                    addition2 = 0;
                    if (x < 6) {
                        x++;
                        checkQuadrant(z);
                    } else {
                        timer.stop();
                    }
                } else if (z == x) {
                    joueurs[z].getHand0().setPositionX(tableauPositionHand0[x][0]);
                    joueurs[z].getHand0().setPositionY(tableauPositionHand0[x][1]);
                    g.drawImage(joueurs[z].getHand0().getImage(), joueurs[z].getHand0().getPositionX(), joueurs[z].getHand0().getPositionY(), null);
                    addition1 = 0;
                    addition2 = 0;
                    if (z < 6) {
                        z++;
                        checkQuadrant(x);
                    }
                }
            }
        }

        for (int i = 0; i < z; i++) {
            g.drawImage(joueurs[i].getHand0().getImage(), joueurs[i].getHand0().getPositionX(), joueurs[i].getHand0().getPositionY(), null);
        }

        for (int i = 0; i < x; i++) {
            g.drawImage(joueurs[i].getHand1().getImage(), joueurs[i].getHand1().getPositionX(), joueurs[i].getHand1().getPositionY(), null);
        }
        //System.out.println(x);
        //System.out.println(z);
        if (Evenements.flop == true) {
            g.drawImage(nouveau.getFlop1().getImage(), 296, 220, null);
            g.drawImage(nouveau.getFlop2().getImage(), 366, 220, null);
            g.drawImage(nouveau.getFlop3().getImage(), 436, 220, null);
        }
        if (Evenements.turn == true) {
            g.drawImage(nouveau.getTurn().getImage(), 506, 220, null);

        }
        if (Evenements.river == true) {
            g.drawImage(nouveau.getRiver().getImage(), 576, 220, null);
        }

    }
}
